<h1 id="-">第十四章</h1>
<hr>
<h2 id="yaml">YAML</h2>
<p>在某些时候，大多数桌面应用程序都希望在磁盘上保存和读取结构化数据。我们已经看到了如何使用简单的 IO 例程（如 <code>gets</code> 和 <code>puts</code>）读取和写入数据。但是，如何编写保存和恢复混合对象类型列表中的数据？使用 Ruby 执行此操作的一种简单方法是使用 YAML。</p>
<div class="note">

<p><strong>YAML</strong> 是 &quot;Yet An-other Markup Language&quot;（仍是一种标记语言，有争议）或 &quot;YAML Ain&#39;t Markup Language&quot; （不是标记语言，递归的）的首字母缩写。</p>
</div>

<h3 id="-yaml">转换成 YAML</h3>
<p>YAML 定义了一种序列化（数据保存）格式，它将信息存储为人类可读的文本。YAML 可以与各种编程语言一起使用，为了在 Ruby 中使用它，你的代码需要使用 <strong>yaml.rb</strong> 文件。通常，这可以通过在代码单元的顶部加载或“引入”（requiring）文件来完成，如下所示：</p>
<pre><code><span class="hljs-built_in">require</span> <span class="hljs-string">'yaml'</span></code></pre><p>完成此操作后，你将可以访问各种方法将 Ruby 对象转换为 YAML 格式，以便将其数据写入文件。随后，你将能够回读已保存的数据并使用它来重新构造 Ruby 对象。</p>
<p>要将对象转换为 YAML 格式，可以使用 <code>to_yaml</code> 方法。它可以转换任何对象 - 字符串，整数，数组，哈希等。例如，这是转换字符串的方式：</p>
<div class="code-file clearfix"><span>to_yaml1.rb</span></div>

<pre><code><span class="hljs-string">"hello world"</span><span class="hljs-string">.to_yaml</span></code></pre><p>这是如何转换数组：</p>
<pre><code>[<span class="hljs-meta"><span class="hljs-meta-string">"a1"</span>, <span class="hljs-meta-string">"a2"</span> </span>].to_yaml</code></pre><p>这是你通过此数组转换获得的 YAML 格式：</p>
<pre><code><span class="hljs-meta">---</span>
<span class="hljs-bullet">-</span> <span class="hljs-string">a1</span>
<span class="hljs-bullet">-</span> <span class="hljs-string">a2</span></code></pre><p>请注意定义新 YAML &#39;文档&#39;的开头的三个破折号以及定义列表中每个新元素的单个破折号。有关 YAML 格式的更多信息，请参阅本章末尾的“深入探索”部分。</p>
<p>你还可以将非标准类型的对象转换为 YAML。例如，假设你创建了此类和对象...</p>
<div class="code-file clearfix"><span>to_yaml2.rb</span></div>

<pre><code><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyClass</span></span>
  <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">initialize</span><span class="hljs-params">( anInt, aString )</span></span>
    @myint = anInt
    @mystring =aString
  <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>

ob1 = MyClass.new( <span class="hljs-number">100</span>, <span class="hljs-string">"hello world"</span> ).to_yaml</code></pre><p>此对象的 YAML 表示形式将以文本 <code>!ruby/object:</code> 开头，后跟类名，每行一个变量名称附加冒号（但减去 <code>@</code>）及其值：</p>
<pre><code>--- !ruby/<span class="hljs-string">object:</span>MyClass
<span class="hljs-string">myint:</span> <span class="hljs-number">100</span>
<span class="hljs-string">mystring:</span> hello world</code></pre><p>如果要打印出对象的 YAML 表示，可以使用方法 <code>y()</code>，它是一种 YAML 的方法，等同于我们熟知的用来查看并打印正常的 Ruby 对象的 <code>p()</code> 方法：</p>
<div class="code-file clearfix"><span>yaml_test1.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-title">y</span><span class="hljs-params">( [<span class="hljs-string">'Bert'</span>, <span class="hljs-string">'Fred'</span>, <span class="hljs-string">'Mary'</span>] )</span></span></code></pre><p>这将显示：</p>
<pre><code><span class="hljs-meta">---</span>
<span class="hljs-bullet">-</span> <span class="hljs-string">Bert</span>
<span class="hljs-bullet">-</span> <span class="hljs-string">Fred</span>
<span class="hljs-bullet">-</span> <span class="hljs-string">Mary</span></code></pre><p>你可以同样的显示一个哈希对象...</p>
<pre><code>y( { <span class="hljs-string">'fruit'</span> =&gt; <span class="hljs-string">'banana'</span>, :vegetable =&gt; <span class="hljs-string">'cabbage'</span>, <span class="hljs-string">'number'</span> =&gt; <span class="hljs-number">3</span> } )</code></pre><p>...在这种情况下，每个键/值对都放在一个新行上：</p>
<pre><code><span class="hljs-meta">---</span>
<span class="hljs-attr">number:</span> <span class="hljs-number">3</span>
<span class="hljs-attr">fruit:</span> <span class="hljs-string">banana</span>
<span class="hljs-string">:vegetable:</span> <span class="hljs-string">cabbage</span></code></pre><p>或者你可以显示自己的“自定义”对象...</p>
<pre><code>t = Treasure.new( <span class="hljs-string">'magic lamp'</span>, <span class="hljs-number">500</span> )
<span class="hljs-function"><span class="hljs-title">y</span><span class="hljs-params">( t )</span></span></code></pre><p>...它显示的数据，如前面我使用 <code>to_yaml</code> 的示例一样，顶部是类名以及连续行上是一对变量名和值：</p>
<pre><code>--- !ruby/<span class="hljs-string">object:</span>Treasure
<span class="hljs-string">name:</span> magic lamp
<span class="hljs-string">value:</span> <span class="hljs-number">500</span></code></pre><div class="code-file clearfix"><span>yaml_test2.rb</span></div>

<p>你甚至可以使用 <code>y()</code> 来显示非常复杂的对象，例如嵌套数组：</p>
<pre><code>arr1 = [ [<span class="hljs-string">"The Groovesters"</span>, <span class="hljs-string">"Groovy Tunes"</span>, <span class="hljs-number">12</span> ],
        [ <span class="hljs-string">"Dolly Parton"</span>, <span class="hljs-string">"Greatest Hits"</span>, <span class="hljs-number">38</span> ]
    ]

y( arr1 )</code></pre><p>...或包含任意类型对象的数组：</p>
<pre><code>arr2 = [ CD.<span class="hljs-keyword">new</span><span class="hljs-type"></span>(<span class="hljs-string">"The Beasts"</span>, <span class="hljs-string">"Beastly Tunes"</span>, <span class="hljs-number">22</span>),
        CD.<span class="hljs-keyword">new</span><span class="hljs-type"></span>(<span class="hljs-string">"The Strolling Bones"</span>, <span class="hljs-string">"Songs For Senior Citizens"</span>, <span class="hljs-number">38</span>)
    ]

y( arr2 )</code></pre><h3 id="-">嵌套序列</h3>
<p>当相关的数据序列（例如数组）嵌套在其它数据序列中时，这种关系由缩进表示。所以，例如，假设我们在 Ruby 中声明了这个数组...</p>
<div class="code-file clearfix"><span>nested_arrays.rb</span></div>

<pre><code>arr = [<span class="hljs-number">1</span>,[<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,[<span class="hljs-number">4</span>,<span class="hljs-number">5</span>,<span class="hljs-number">6</span>,[<span class="hljs-number">7</span>,<span class="hljs-number">8</span>,<span class="hljs-number">9</span>,<span class="hljs-number">10</span>],<span class="hljs-string">"end3"</span>],<span class="hljs-string">"end2"</span>],<span class="hljs-string">"end1"</span>]</code></pre><p>当呈现为 YAML（例如，通过 <code>y(arr)</code>）时，这变为：</p>
<pre><code>-<span class="ruby">--
</span>-<span class="ruby"> <span class="hljs-number">1</span>
</span>-<span class="ruby"> - <span class="hljs-number">2</span>
</span>  -<span class="ruby"> <span class="hljs-number">3</span>
</span>  -<span class="ruby"> - <span class="hljs-number">4</span>
</span>    -<span class="ruby"> <span class="hljs-number">5</span>
</span>    -<span class="ruby"> <span class="hljs-number">6</span>
</span>    -<span class="ruby"> - <span class="hljs-number">7</span>
</span>      -<span class="ruby"> <span class="hljs-number">8</span>
</span>      -<span class="ruby"> <span class="hljs-number">9</span>
</span>      -<span class="ruby"> <span class="hljs-number">10</span>
</span>    -<span class="ruby"> end3
</span>  -<span class="ruby"> end2
</span>-<span class="ruby"> end1</span></code></pre><h3 id="-yaml-">保存 YAML 数据</h3>
<p><code>dump</code> 方法提供了另一种方便的方式将 Ruby 对象转换为 YAML 格式。最简单的是，它会将你的 Ruby 数据转换为 YAML 格式并将其转储为字符串：</p>
<div class="code-file clearfix"><span>yaml_dump1.rb</span></div>

<pre><code><span class="hljs-attr">arr</span> = [<span class="hljs-string">"fred"</span>, <span class="hljs-string">"bert"</span>, <span class="hljs-string">"mary"</span>]
<span class="hljs-attr">yaml_arr</span> = YAML.dump( arr )    # yaml_arr is now: <span class="hljs-string">"--- \n- fred\n- bert\n- mary\n"</span></code></pre><p>更有用的是，<code>dump</code> 方法可以接收第二个参数，它是某种 IO 对象，通常是文件（file）。你可以打开文件并将数据转储给它...</p>
<div class="code-file clearfix"><span>yaml_dump2.rb</span></div>

<pre><code>f = <span class="hljs-built_in">File</span>.<span class="hljs-built_in">open</span>( <span class="hljs-string">'friends.yml'</span>, <span class="hljs-string">'w'</span> )
YAML.dump( [<span class="hljs-string">"fred"</span>, <span class="hljs-string">"bert"</span>, <span class="hljs-string">"mary"</span>], f )
f.<span class="hljs-built_in">close</span></code></pre><p>...或者你可以打开文件（或其它类型的 IO 对象）并将其传递到关联的块中：</p>
<pre><code><span class="hljs-built_in">File</span>.<span class="hljs-built_in">open</span>( <span class="hljs-string">'morefriends.yml'</span>, <span class="hljs-string">'w'</span> ){ |friendsfile|
    YAML.dump( [<span class="hljs-string">"sally"</span>, <span class="hljs-string">"agnes"</span>, <span class="hljs-string">"john"</span> ], friendsfile )
}</code></pre><p>如果使用块，则退出块时文件将自动关闭，否则应使用 <code>close</code> 方法显式关闭文件。顺便提一下，你也可以以类似的方式使用块来打开文件并读入 YAML 数据：</p>
<pre><code><span class="hljs-keyword">File</span>.<span class="hljs-literal">open</span>( <span class="hljs-string">'morefriends.yml'</span> ){ |f|
    <span class="hljs-variable">$arr</span>= YAML.load(f)
}</code></pre><h3 id="-">保存时忽略变量</h3>
<p>如果由于某种原因，在序列化对象时要省略某些实例变量，可以通过定义名为 <code>to_yaml_properties</code> 的方法来实现。</p>
<p>在此方法的主体中，放置一个字符串数组。每个字符串应与要保存的实例变量的名称匹配。任何未指定的变量都不会被保存。看看这个示例：</p>
<div class="code-file clearfix"><span>limit_y.rb</span></div>

<pre><code><span class="hljs-keyword">class</span> <span class="hljs-symbol">Yclass</span>
  <span class="hljs-symbol">def</span> <span class="hljs-symbol">initialize</span>(<span class="hljs-symbol">aNum, <span class="hljs-symbol">aStr</span>, <span class="hljs-symbol">anArray</span></span>)
    @<span class="hljs-symbol">num</span> = <span class="hljs-symbol">aNum</span>
    @<span class="hljs-symbol">str</span> = <span class="hljs-symbol">aStr</span>
    @<span class="hljs-symbol">arr</span> = <span class="hljs-symbol">anArray</span>
  <span class="hljs-symbol">end</span>

  <span class="hljs-symbol">def</span> <span class="hljs-symbol">to_yaml_properties</span>
    ["@<span class="hljs-symbol">num</span>", "@<span class="hljs-symbol">arr</span>"] #&lt;= @<span class="hljs-symbol">str</span> <span class="hljs-symbol">will</span> <span class="hljs-symbol">not</span> <span class="hljs-symbol">be</span> <span class="hljs-symbol">saved</span>!
  <span class="hljs-symbol">end</span>
<span class="hljs-symbol">end</span></code></pre><p>这里 <code>to_yaml_properties</code> 限制了当你调用 <code>YAML.dump</code> 时被保存的变量仅为 <code>@num</code> 和 <code>@arr</code>。字符串变量 <code>@str</code> 将不会被保存。如果你以后希望根据保存的 YAML 数据重建对象，则你有义务确保“缺失”变量是不被需要的（在这种情况下可以忽略它们），或者如果需要，它们应该用一些有意义的值初始化：</p>
<pre><code>ob = <span class="hljs-type">Yclass</span>.<span class="hljs-keyword">new</span>( <span class="hljs-number">100</span>, <span class="hljs-string">"fred"</span>, [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>] )    # ...creates <span class="hljs-class"><span class="hljs-keyword">object</span> <span class="hljs-keyword">with</span> <span class="hljs-title">@num=100</span>, <span class="hljs-title">@str=</span>"<span class="hljs-title">fred</span>", <span class="hljs-title">@arr=</span>[1,2,3]</span>

yaml_ob = <span class="hljs-type">YAML</span>.dump( ob ) #...dumps to <span class="hljs-type">YAML</span> only the <span class="hljs-meta">@num</span> and <span class="hljs-meta">@arr</span> data (omits <span class="hljs-meta">@str</span>)

ob2 = <span class="hljs-type">YAML</span>.load( yaml_ob )    #...creates ob2 from dumped data <span class="hljs-keyword">with</span> <span class="hljs-meta">@num</span>=<span class="hljs-number">100</span>, <span class="hljs-meta">@arr</span>=[<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>] , but without <span class="hljs-meta">@str</span></code></pre><h3 id="-">一个文件中多个文档</h3>
<p>早些时候，我提到过三个破折号用于标记新的 YAML “文档”（document）的开头。在 YAML 术语中，文档是离散的组或片段。单个文件可能包含许多此类“文档”。</p>
<p>例如，假设你要将两个数组 <code>arr1</code> 和 <code>arr2</code> 保存到文件 <strong>&#39;multidoc.yml&#39;</strong>。 这里 <code>arr1</code> 是一个包含两个嵌套数组的数组，<code>arr2</code> 是一个包含两个 CD 对象的数组：</p>
<div class="code-file clearfix"><span>multi_docs.rb</span></div>

<pre><code>arr1 = [ [<span class="hljs-string">"The Groovesters"</span>, <span class="hljs-string">"Groovy Tunes"</span>, <span class="hljs-number">12</span> ],
        [ <span class="hljs-string">"Dolly Parton"</span>, <span class="hljs-string">"Greatest Hits"</span>, <span class="hljs-number">38</span> ]
    ]

arr2 = [ CD.<span class="hljs-keyword">new</span><span class="hljs-type"></span>(<span class="hljs-string">"Gribbit Mcluskey"</span>, <span class="hljs-string">"Fab Songs"</span>, <span class="hljs-number">22</span>),
        CD.<span class="hljs-keyword">new</span><span class="hljs-type"></span>(<span class="hljs-string">"Wayne Snodgrass"</span>, <span class="hljs-string">"Singalong-a-Snodgrass"</span>, <span class="hljs-number">24</span>)
    ]</code></pre><p>这是我将这些数组转储到 YAML 并将它们写入文件的例程（如第 13 章所述，<code>&#39;w&#39;</code> 参数导致文件以写入模式被打开）：</p>
<pre><code><span class="hljs-keyword">File</span>.open( <span class="hljs-string">'multidoc.yml'</span>, <span class="hljs-string">'w'</span> ){ |f|
    YAML.<span class="hljs-keyword">dump</span>( arr1, f )
    YAML.<span class="hljs-keyword">dump</span>( arr2, f )
}</code></pre><p>查看文件 <strong>&#39;multidoc.yml&#39;</strong>，你将看到数据已保存为两个单独的&#39;文档&#39; - 每个文档以三个破折号开头：</p>
<pre><code><span class="hljs-meta">---</span>
<span class="hljs-bullet">-</span> <span class="hljs-bullet">-</span> <span class="hljs-string">The</span> <span class="hljs-string">Groovesters</span>
<span class="hljs-bullet">  -</span> <span class="hljs-string">Groovy</span> <span class="hljs-string">Tunes</span>
<span class="hljs-bullet">  -</span> <span class="hljs-number">12</span>
<span class="hljs-bullet">-</span> <span class="hljs-bullet">-</span> <span class="hljs-string">Dolly</span> <span class="hljs-string">Parton</span>
<span class="hljs-bullet">  -</span> <span class="hljs-string">Greatest</span> <span class="hljs-string">Hits</span>
<span class="hljs-bullet">  -</span> <span class="hljs-number">38</span>
<span class="hljs-meta">---</span>
<span class="hljs-bullet">-</span> <span class="hljs-type">!ruby</span><span class="hljs-string">/object:CD</span>
<span class="hljs-attr">  artist:</span> <span class="hljs-string">Gribbit</span> <span class="hljs-string">Mcluskey</span>
<span class="hljs-attr">  name:</span> <span class="hljs-string">Fab</span> <span class="hljs-string">Songs</span>
<span class="hljs-attr">  numtracks:</span> <span class="hljs-number">22</span>
<span class="hljs-bullet">-</span> <span class="hljs-type">!ruby</span><span class="hljs-string">/object:CD</span>
<span class="hljs-attr">  artist:</span> <span class="hljs-string">Wayne</span> <span class="hljs-string">Snodgrass</span>
<span class="hljs-attr">  name:</span> <span class="hljs-string">Singalong-a-Snodgrass</span>
<span class="hljs-attr">  numtracks:</span> <span class="hljs-number">24</span></code></pre><p>现在，我需要找到一种通过将数据作为两个文档读取来重建这些数组的方法。<code>load_documents</code> 方法提供了该解决方式。</p>
<p><code>load_documents</code> 方法调用一个块并将每个连续文档传递给它。下面是一个如何使用此方法从两个 YAML 文档重建两个数组（放在另一个数组 <code>$new_arr</code> 中）的示例：</p>
<pre><code><span class="hljs-type">File</span>.open( <span class="hljs-string">'multidoc.yml'</span> ) {|f|
  <span class="hljs-type">YAML</span>.load_documents( f ) { |doc|
    <span class="hljs-string">$n</span>ew_arr &lt;&lt; doc
  }
}</code></pre><p>你可以通过执行以下操作来验证是否已使用两个数组初始化 <code>$new_arr</code>：</p>
<pre><code><span class="hljs-function"><span class="hljs-title">puts</span><span class="hljs-params">( <span class="hljs-string">"$new_arr contains #{$new_arr.size} elements"</span> )</span></span>
<span class="hljs-function"><span class="hljs-title">p</span><span class="hljs-params">( <span class="hljs-variable">$new_arr</span>[<span class="hljs-number">0</span>] )</span></span>
<span class="hljs-function"><span class="hljs-title">p</span><span class="hljs-params">( <span class="hljs-variable">$new_arr</span>[<span class="hljs-number">1</span>] )</span></span></code></pre><p>或者，这是一种更通用的做同样事情的方法，它适用于任何长度的数组：</p>
<pre><code>$new_arr.each{ |<span class="hljs-type">arr</span>| <span class="hljs-type">p</span>( arr ) }</code></pre><h3 id="yaml-">YAML 数据库</h3>
<p>有关以 YAML 格式保存和加载数据的稍微复杂的应用程序的示例，你可能需要查看 <strong>cd_db.rb</strong>。这里实现了一个简单的 CD 数据库。它定义了三种类型的 CD 对象 - 一个基本 CD，其中包含有关名称，艺术家和轨道数量的数据以及两个更专业的后代类 - PopCD，它添加了关于类型（例如“摇滚”或“乡村”）的数据以及 ClassicalCD 添加了导师和作曲家的数据。</p>
<p>当程序运行时，用户可以输入数据以创建这三种类型中的任何一种的新 CD 对象。还有一个将数据保存到磁盘的选项。随后运行应用程序时，将重新加载现有数据。</p>
<p>数据本身在代码中被组织得非常简单（甚至微不足道！），在创建对象本身之前将每个对象的数据读入数组。整个 CD 对象数据库被保存到全局变量 <code>$cd_arr</code> 中，并将其写入磁盘并使用 YAML 方法重新加载到内存中：</p>
<div class="code-file clearfix"><span>cd_db.rb</span></div>

<pre><code><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">saveDB</span></span>
  File.open( $fn, <span class="hljs-string">'w'</span> ) {
      <span class="hljs-params">|f|</span>
      f.write($cd_arr.to_yaml)
  }
<span class="hljs-keyword">end</span>

<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">loadDB</span></span>
  input_data = File.read( $fn )
  $cd_arr = YAML::load( input_data )
<span class="hljs-keyword">end</span></code></pre><p>在现实世界的应用程序中，我确信你希望创建一些更优雅的数据结构来管理你的 Dolly Parton 集合！</p>
<h3 id="yaml-">YAML 冒险游戏</h3>
<p>作为使用 YAML 的最后一个示例，我为冒险游戏（<strong>gamesave_y.rb</strong>）提供了一个基本框架。这会创建一些 Treasure 对象和一些 Room 对象。Treasure 对象被放入 Room 对象中（也就是说，它们被放置在 Rooms 包含的数组中），然后 Room 对象被放入 Map 对象中。这具有构造中等复杂数据结构的效果，其中一种类型的对象（Map）包含任意数量的另一种类型的对象（Rooms），每个 Room 对象可以包含零个或多个其它类型的对象（Treasures））。</p>
<p>乍一看，找到一种将混合对象类型的整个网络存储到磁盘并在稍后重建该网络的方法可能看起来像编程噩梦。</p>
<p>事实上，由于 Ruby 的 YAML 库提供的序列化功能，保存和恢复这些数据几乎没有更容易的了。这是因为序列化（serialization）减轻了你逐个保存每个对象的繁琐工作。相反，你只需要“转储”（dump）顶级对象 - 这里就是 Map 对象 <code>mymap</code>。</p>
<p>完成此操作后，将自动为你保存顶级对象“包含”的任何对象（如 Rooms）或被包含对象本身包含的对象（如 Treasures）。然后可以通过在单个操作中加载所有已保存的数据并将其分配给“顶级”对象（此处为 map）来重建它们：</p>
<div class="code-file clearfix"><span>gamesave_y.rb</span></div>

<pre><code><span class="hljs-comment"># Save mymap</span>
<span class="hljs-keyword">File</span>.<span class="hljs-literal">open</span>( <span class="hljs-string">'game.yml'</span>, <span class="hljs-string">'w'</span> ){ |f|
  YAML.dump( mymap, f )
}

<span class="hljs-comment"># Reload mymap</span>
<span class="hljs-keyword">File</span>.<span class="hljs-literal">open</span>( <span class="hljs-string">'game.yml'</span> ){ |f|
  mymap = YAML.load(f)
}</code></pre><h2 id="-">深入探索</h2>
<h3 id="yaml-">YAML 的简要指南</h3>
<p>在 YAML 中，数据被分成包含“序列”（sequences）数据的“文档”。每个文档以三个短划线字符 <code>---</code> 开头，列表中的每个单独元素都以单个短划线字符 <code>-</code> 开头。因此，例如，这是一个 YAML 数据文件，包含一个文档和两个列表项：</p>
<pre><code><span class="hljs-meta">---</span>
<span class="hljs-attr">- artist:</span> <span class="hljs-string">The</span> <span class="hljs-string">Groovesters</span>
<span class="hljs-attr">  name:</span> <span class="hljs-string">Groovy</span> <span class="hljs-string">Tunes</span>
<span class="hljs-attr">  numtracks:</span> <span class="hljs-number">12</span>
<span class="hljs-attr">- artist:</span> <span class="hljs-string">Dolly</span> <span class="hljs-string">Parton</span>
<span class="hljs-attr">  name:</span> <span class="hljs-string">Greatest</span> <span class="hljs-string">Hits</span>
<span class="hljs-attr">  numtracks:</span> <span class="hljs-number">38</span></code></pre><p>在上面的示例中，你可以看到每个列表项由两部分组成 - 名称如 <code>artist:</code>（在每个列表项中相同）和右侧的一段数据，例如 <code>Dolly Parton</code>，可能因每个列表项而异。这些项类似于 Ruby 的 Hash 中的键值对。YAML 将键值列表称为“映射”（maps）。</p>
<p>下面是一个包含两个项目的列表的 YAML 文档，每个项目包含三个项目 - 换句话说，它是包含两个三项“嵌套”数组的数组的 YAML 表示形式：</p>
<pre><code><span class="hljs-meta">---</span>
<span class="hljs-bullet">-</span> <span class="hljs-bullet">-</span> <span class="hljs-string">The</span> <span class="hljs-string">Groovesters</span>
<span class="hljs-bullet">  -</span> <span class="hljs-string">Groovy</span> <span class="hljs-string">Tunes</span>
<span class="hljs-bullet">  -</span> <span class="hljs-number">12</span>
<span class="hljs-bullet">-</span> <span class="hljs-bullet">-</span> <span class="hljs-string">Dolly</span> <span class="hljs-string">Parton</span>
<span class="hljs-bullet">  -</span> <span class="hljs-string">Greatest</span> <span class="hljs-string">Hits</span>
<span class="hljs-bullet">  -</span> <span class="hljs-number">38</span></code></pre><p>现在让我们看看 YAML 如何处理嵌套的哈希（Hashes）。</p>
<p>思考这个 Hash：</p>
<div class="code-file clearfix"><span>hash_to_yaml.rb</span></div>

<pre><code>hsh = { :<span class="hljs-function"><span class="hljs-params">friend1</span> =&gt;</span> <span class="hljs-string">'mary'</span>,
        :<span class="hljs-function"><span class="hljs-params">friend2</span> =&gt;</span> <span class="hljs-string">'sally'</span>,
        :<span class="hljs-function"><span class="hljs-params">friend3</span> =&gt;</span> <span class="hljs-string">'gary'</span>,
        :<span class="hljs-function"><span class="hljs-params">morefriends</span> =&gt;</span> { :<span class="hljs-function"><span class="hljs-params">chap_i_met_in_a_bar</span> =&gt;</span> <span class="hljs-string">'simon'</span>,
                          :<span class="hljs-function"><span class="hljs-params">girl_next_door</span> =&gt;</span> <span class="hljs-string">'wanda'</span>
                        }
}</code></pre><p>正如我们已经看到的，Hash 在 YAML 中很自然地表示为键值对列表。但是，在上面显示的示例中，关键字 <code>:morefriends</code> 与嵌套哈希值相关联。YAML 如何表示？事实证明，与数组一样（参见本章前面的<em>“嵌套序列”</em>），它只是缩进嵌套的哈希：</p>
<pre><code><span class="hljs-meta">:friend1:</span> mary
<span class="hljs-meta">:friend2:</span> sally
<span class="hljs-meta">:friend3:</span> gary
<span class="hljs-meta">:morefriends:</span>
<span class="hljs-code">  :chap_i_met_in_a_bar: simon</span>
<span class="hljs-code">  :girl_next_door: wanda</span></code></pre><div class="note">

<p>有关 YAML 的详细信息，请访问 <strong><a href="http://yaml.org">http://yaml.org</a></strong></p>
</div>

<p>随 Ruby 提供的 YAML 库非常庞大且复杂，并且有许多方法可供你使用，而不仅是本章所述的。但是，你现在应该对 YAML 有了足够的了解，以便在你自己的程序中使用它。你可以在闲暇时慢慢地探索 YAML 库。</p>
<p>但事实证明，YAML 并不是在 Ruby 中序列化数据的唯一方法。我们将在下一章中讨论另一种方式。</p>
